#include "UsrAI.h"
#include<set>
#include <iostream>
#include<unordered_map>
#include<map>
#include<queue>
#include<fstream>
using namespace std;
tagGame tagUsrGame;
ins UsrIns;
#define map_size 128//地图大小常量
#define height_max '3'//陆地高度最大值
#define height_min '0'//陆地高度最小值
#define unit_max 8//最多有8个方向
#define unit_min 4//最少有4个方向
#define home_min 3//最少3个房子
struct Position//定义一个结构体Point来存储坐标信息
{
    int x;
    int y;
    bool operator <(const Position& z)const
    {
        return (x*x+y*y)<(z.x*z.x+z.y*z.y);
    }
};
void simple_map(char(&MAP)[map_size][map_size],tagInfo& info,map<int,int>&SN_to_sort,map<int,tagResource>&SN_to_resource,map<int,tagBuilding>&SN_to_building,map<Position,int>&Position_to_SN);
int OUTOFrange(const int &x);
int IS_land(const char &z);
Position Find_position(char(&MAP)[map_size][map_size],int blockdr,int blockur,int type);
void MAP_print(char(&MAP)[map_size][map_size],int &flag);
void transform_vector(vector<tagFarmer>& farmer1,vector<tagFarmer>& farmer2);
void transform_vector(vector<tagArmy>& army1,vector<tagArmy>& army2);
bool isenemyland(bool(&visited)[map_size][map_size],char(&MAP)[map_size][map_size]);
void UsrAI::processData()
{
    tagInfo info = getInfo();//获得所有信息
    char MAP[map_size][map_size];//初始化实时地图
    static bool visited[map_size][map_size]={false};//用于探索判断
    map<int,int>SN_to_sort;//建立SN到类型的映射,暂时不考虑军队单位
    map<int,tagResource>SN_to_resource;//建立资源SN到资源的映射
    map<int,tagBuilding>SN_to_building;//建立建筑SN到建筑的映射
    map<Position,int>Position_to_SN;//建立块坐标到资源SN的映射
    simple_map(MAP,info,SN_to_sort,SN_to_resource,SN_to_building,Position_to_SN);//调用函数simple_map，获得实时地图，并完成所有映射，此处不判断斜面
    vector<tagFarmer>idlefarmer;//闲置农民
    vector<tagFarmer>treefarmer;//砍树农民
    vector<tagFarmer>farmfarmer;//造采农田农民
    vector<tagFarmer>gazellefarmer;//捕瞪羚农民
    vector<tagFarmer>buildinghomefarmer;//造房子农民
    vector<tagFarmer>buildingdockfarmer;//造船坞农民
    vector<tagFarmer>buildingstockfarmer;//造仓库农民
    vector<tagFarmer>buildingmarketfarmer;//造市场农民
    vector<tagFarmer>buildinggranaryfarmer;//造谷仓农民
    vector<tagFarmer>stonefarmer;//采石头农民
    vector<tagFarmer>idlesailing;//闲置渔船
    vector<tagFarmer>fishsailing;//捕鱼渔船
    vector<tagArmy>idleship;//空闲战船
    vector<tagArmy>moveship;//移动战船
    vector<tagArmy>attackship;//攻击战船
    vector<tagFarmer>idleboat;//空闲运输船
    vector<tagFarmer>moveboat;//移动运输船
    vector<tagFarmer>onboatfarmer;//在船上的农民
    static vector<Position>movetowards;//记录要移动的点
    //将农民按工作分类
    int farmerN=0;//记录村民数量
    for(tagFarmer& farmer:info.farmers)
    {
        if(farmer.FarmerSort==0)//是农民
        {
            farmerN++;
            if(farmer.NowState== HUMAN_STATE_IDLE)//状态为空闲
            {
                idlefarmer.push_back(farmer);//空闲村民
            }
            if(farmer.NowState==HUMAN_STATE_WORKING)//状态为工作
            {
                int type=SN_to_sort[farmer.WorkObjectSN];//映射判断类型
                switch(type)
                {
                case RESOURCE_TREE://砍树村民
                    treefarmer.push_back(farmer);
                    break;
                case RESOURCE_GAZELLE://捕瞪羚村民
                    gazellefarmer.push_back(farmer);
                    break;
                case BUILDING_HOME://造房子村民
                    buildinghomefarmer.push_back(farmer);
                    break;
                case BUILDING_DOCK://造船坞村民
                    buildingdockfarmer.push_back(farmer);
                    break;
                case BUILDING_STOCK://造仓库村民
                    buildingstockfarmer.push_back(farmer);
                    break;
                case BUILDING_MARKET://造市场村民
                    buildingmarketfarmer.push_back(farmer);
                    break;
                case BUILDING_GRANARY://造谷仓村民
                    buildinggranaryfarmer.push_back(farmer);
                    break;
                case BUILDING_FARM://造采农田农民
                    farmfarmer.push_back(farmer);
                    break;
                case RESOURCE_STONE://采石头农民
                    stonefarmer.push_back(farmer);
                    break;
                }
            }
        }
        else if(farmer.FarmerSort==2)//是渔船
        {
            if(farmer.NowState==HUMAN_STATE_IDLE)//状态为空闲
            {
                idlesailing.push_back(farmer);//空闲渔船
            }
            else if(farmer.NowState==HUMAN_STATE_WORKING)
            {
                fishsailing.push_back(farmer);//捕鱼渔船
            }
        }
        else if(farmer.FarmerSort==1)//是运输船
        {
            if(farmer.NowState==HUMAN_STATE_IDLE)
            {
                idleboat.push_back(farmer);//空闲运输船
            }
            else if(farmer.NowState==HUMAN_STATE_WALKING)
            {
                moveboat.push_back(farmer);//移动运输船
            }
        }
    }
    int shipN=0;
    //将军队分类
    for(tagArmy&army:info.armies)
    {
        if(army.NowState==HUMAN_STATE_IDLE)//状态为空闲
        {
            switch(army.Sort)
            {
            case AT_SHIP://战船
                shipN++;
                idleship.push_back(army);
                break;
            }
        }
        else if(army.NowState==HUMAN_STATE_WALKING)
        {
            switch(army.Sort)
            {
            case AT_SHIP://战船
                shipN++;
                moveship.push_back(army);
                break;
            }
        }
        else if(army.NowState==HUMAN_STATE_ATTACKING)
        {
            switch(army.Sort)
            {
            case AT_SHIP://战船
                shipN++;
                attackship.push_back(army);
                break;
            }
        }
    }
    tagBuilding building_center;//记录市镇中心
    static int building_dock_SN;//记录building_dock的SN
    static int building_dock2_SN;//记录building_dock2的SN
    tagBuilding building_dock;//记录船坞
    tagBuilding building_dock2;//记录船坞2
    static tagBuilding building_stock;//记录仓库
    static int stage = 1;//全局变量记录阶段
    static int towards=0;//变换移动位置
    for(tagBuilding& building:info.buildings)
    {
        if(building.Type==BUILDING_CENTER)//记录市镇中心
        {
            building_center=building;
        }
        else if(building.Type==BUILDING_DOCK)//记录两个船坞
        {
            if(building.SN==building_dock_SN)
            {
                building_dock=building;
            }
            else if(building.SN==building_dock2_SN)
            {
                building_dock2=building;
            }
        }
    }
    static Position homep;//记录房子地址
    static int HomeN=0;//记录房子数
    tagArmy* enemy_ship=nullptr;//记录敌船
    if(stage==1)//阶段1:连续生产村民，村民在岸边渔场捕鱼、捕猎，建设船坞生产渔船，以快速获取食物，砍伐树木、开采石头、建造房屋等基础设施，有足够资源时升级时代。
    {
        static bool is_visited=false;//执行一次记录视野
        if(!is_visited)
        {
            for(int i=0;i<map_size;i++)
            {
                for(int j=0;j<map_size;j++)
                {
                    if(MAP[i][j]!='*')
                    {
                        visited[i][j]=true;
                    }
                }
            }
            is_visited=true;
        }
        static bool build_home=false;//只执行一次
        if(idlefarmer.size()>0&&info.Wood>=30&&!build_home)//在市镇中心周围建第一个房子
        {
            homep=Find_position(MAP,building_center.BlockDR+1,building_center.BlockUR+1,BUILDING_CENTER);//以市镇中心为中心找到能建房子的地点
            HumanBuild(idlefarmer.back().SN,BUILDING_HOME,homep.x,homep.y);//令村民建造房子
            transform_vector(idlefarmer,buildinghomefarmer);//将村民从空闲转移至建房子中
            HomeN++;
            info.Wood-=30;//纠正数量防冲突
            build_home=true;//只执行一次
        }
        if(HomeN<home_min&&idlefarmer.size()>0&&buildinghomefarmer.empty()&&info.Wood>=30&&HomeN<home_min)//如果房子数没到3,造房子
        {
            homep=Find_position(MAP,homep.x,homep.y,BUILDING_HOME);//以房子为中心找到能建房子的地点
            HumanBuild(idlefarmer.back().SN,BUILDING_HOME,homep.x,homep.y);//令村民建造房子
            transform_vector(idlefarmer,buildinghomefarmer);//将村民从空闲转移至建房子中
            HomeN++;
            info.Wood-=30;//纠正数量防冲突
        }
        if(info.Human_MaxNum>4&&farmerN<8&&info.Meat>=50&&building_center.Project==0)//使村民数达到8人
        {
            BuildingAction(building_center.SN,BUILDING_CENTER_CREATEFARMER);
            info.Meat-=50;//纠正数量防冲突
        }
        static bool dock_build=false;//执行一次造船坞
        if(!dock_build&&idlefarmer.size()>0&&info.Wood>=120)//造船坞
        {
            Position p=Find_position(MAP,idlefarmer.back().BlockDR,idlefarmer.back().BlockUR,BUILDING_DOCK);//找到能建船坞的地点
            HumanBuild(idlefarmer.back().SN,BUILDING_DOCK,p.x,p.y);//建造船坞
            transform_vector(idlefarmer,buildingdockfarmer);//将村民从空闲放到建船坞中
            dock_build=true;//只执行一次
            info.Wood-=120;//纠正数量防冲突
        }
        if(!buildingdockfarmer.empty())
        {
            building_dock_SN=buildingdockfarmer.back().WorkObjectSN;//映射到船坞的SN，用于区别另一个船坞
        }
        if(building_dock.Percent>=100&&building_dock.Project==0&&info.Wood>=60&&(idlesailing.size()+fishsailing.size())<4)//如果船坞建好了,且船坞空闲,建4个渔船
        {
            BuildingAction(building_dock.SN,BUILDING_DOCK_CREATE_SAILING);//建造渔船
            info.Wood-=60;//纠正数量防冲突
        }
        static bool gazelle_stock=false;//执行一次在羚羊周围建仓库
        if(!gazelle_stock&&info.Wood>=120)//在瞪羚周围建仓库
        {
            if(idlefarmer.size()>0)
            {
                Position p=Find_position(MAP,idlefarmer.back().BlockDR,idlefarmer.back().BlockUR,RESOURCE_GAZELLE);//记录离村民最近的羚羊的坐标
                Position p1=Find_position(MAP,p.x,p.y,BUILDING_STOCK);//在瞪羚周围寻找能建仓库的地方
                HumanBuild(idlefarmer.back().SN,BUILDING_STOCK,p1.x,p1.y);//派村民前往建造仓库
                transform_vector(idlefarmer,buildingstockfarmer);//将空闲村民放入建仓库村民
                info.Wood-=120;//纠正数量防冲突
                gazelle_stock=true;
            }
            else if(treefarmer.size()>0)
            {
                Position p=Find_position(MAP,treefarmer.back().BlockDR,treefarmer.back().BlockUR,RESOURCE_GAZELLE);//记录离村民最近的羚羊的坐标
                Position p1=Find_position(MAP,p.x,p.y,BUILDING_STOCK);//在瞪羚周围寻找能建仓库的地方
                HumanBuild(treefarmer.back().SN,BUILDING_STOCK,p1.x,p1.y);//派村民前往建造仓库
                transform_vector(treefarmer,buildingstockfarmer);//将空闲村民放入建仓库村民
                info.Wood-=120;//纠正数量防冲突
                gazelle_stock=true;
            }
        }
        if(!buildingstockfarmer.empty())
        {
            building_stock=SN_to_building[buildingstockfarmer.back().WorkObjectSN];//映射到仓库
        }
        if(building_stock.Percent>=100&&gazellefarmer.size()<4)//仓库建好了,派4个村民来打瞪羚
        {
            if(idlefarmer.size()>0)
            {
                Position p=Find_position(MAP,idlefarmer.back().BlockDR,idlefarmer.back().BlockUR,RESOURCE_GAZELLE);//记录离村民最近的瞪羚的坐标
                if(p.x!=-1&&p.y!=-1)//如果还有瞪羚了
                {
                    HumanAction(idlefarmer.back().SN,Position_to_SN[p]);//让该村民去打最近的一只瞪羚
                    transform_vector(idlefarmer,gazellefarmer);//把空闲村民放入打瞪羚村民
                }
            }
            else if(treefarmer.size()>0)
            {
                Position p=Find_position(MAP,treefarmer.back().BlockDR,treefarmer.back().BlockUR,RESOURCE_GAZELLE);//记录离村民最近的瞪羚的坐标
                if(p.x!=-1&&p.y!=-1)//如果还有瞪羚了
                {
                    HumanAction(treefarmer.back().SN,Position_to_SN[p]);//让该村民去打最近的一只瞪羚
                    transform_vector(treefarmer,gazellefarmer);//把砍树村民放入打瞪羚村民
                }
            }
        }
        if(idlesailing.size()>0)//有空闲的渔船
        {
            Position p=Find_position(MAP,idlesailing.back().BlockDR,idlesailing.back().BlockUR,RESOURCE_FISH);//记录离渔船最近的渔场的坐标
            if(p.x!=-1&&p.y!=-1)//找到渔场
            {
                HumanAction(idlesailing.back().SN,Position_to_SN[p]);//派空闲渔船捕鱼
                transform_vector(idlesailing,fishsailing);//将空闲渔船放入捕鱼渔船中
            }
        }
        while(idlefarmer.size()>0)//剩余的村民全部去砍树
        {
            Position p=Find_position(MAP,idlefarmer.back().BlockDR,idlefarmer.back().BlockUR,RESOURCE_TREE);//记录离村民最近的树的坐标
            if(p.x == -1 && p.y == -1)//如果没树了
                break;
            HumanAction(idlefarmer.back().SN,Position_to_SN[p]);//派村民砍树
            transform_vector(idlefarmer,treefarmer);//将空闲村民放入砍树村民
        }
        if(HomeN>=home_min&&info.Meat>=500)//如果粮食大于500
        {
            BuildingAction(building_center.SN,BUILDING_CENTER_UPGRADE);//升级时代
            info.Meat-=500;//纠正数量防冲突
        }
        if(info.civilizationStage==CIVILIZATION_TOOLAGE)
        {
            cout<<"Successfully upgrade to a new era!"<<endl;
            stage++;
        }
    }
    //阶段2
    else if(stage==2)
    {
        static tagBuilding build_granary;//记录谷仓
        static tagBuilding building_market;//记录市场
        static int farmN=0;//记录建农田数量
        static bool wood_upgrade_started=false;//开始升级伐木
        if(idlesailing.size()>0)//有空闲的渔船
        {
            Position p=Find_position(MAP,idlesailing.back().BlockDR,idlesailing.back().BlockUR,RESOURCE_FISH);//记录离渔船最近的渔场的坐标
            if(p.x!=-1&&p.y!=-1)//找到渔场
            {
                HumanAction(idlesailing.back().SN,Position_to_SN[p]);//派空闲渔船捕鱼
                transform_vector(idlesailing,fishsailing);//将空闲渔船放入捕鱼渔船中
            }
        }
        if(!wood_upgrade_started&&idlefarmer.size()>0&&gazellefarmer.size()<4)//派4个村民来打瞪羚
        {
            Position p=Find_position(MAP,idlefarmer.back().BlockDR,idlefarmer.back().BlockUR,RESOURCE_GAZELLE);//记录离村民最近的瞪羚的坐标
            if(p.x!=-1&&p.y!=-1)//如果还有瞪羚
            {
                HumanAction(idlefarmer.back().SN,Position_to_SN[p]);//让该村民去打最近的一只瞪羚
                transform_vector(idlefarmer,gazellefarmer);//把空闲村民放入打瞪羚村民
            }
        }
        if(info.Human_MaxNum>8&&farmerN<12&&info.Meat>=50)//使村民数达到12人
        {
            BuildingAction(building_center.SN,BUILDING_CENTER_CREATEFARMER);
            info.Meat-=50;//纠正数量防冲突
        }
        static bool granary_build=false;//未建谷仓
        if(!granary_build&&info.Wood>=120)//建谷仓
        {
            Position p=Find_position(MAP,building_center.BlockDR+1,building_center.BlockUR+1,BUILDING_GRANARY);//在市镇中心旁找能建谷仓的地方
            if(idlefarmer.size()>0)//有村民空闲
            {
                HumanBuild(idlefarmer.back().SN,BUILDING_GRANARY,p.x,p.y);//建谷仓
                granary_build=true;
                transform_vector(idlefarmer,buildinggranaryfarmer);//闲置村民转到造谷仓村民
                info.Wood-=120;//纠正数量防冲突
            }
            else if(treefarmer.size()>0)
            {
                HumanBuild(treefarmer.back().SN,BUILDING_GRANARY,p.x,p.y);//建谷仓
                granary_build=true;
                transform_vector(treefarmer,buildinggranaryfarmer);//闲置村民转到造谷仓村民
                info.Wood-=120;//纠正数量防冲突
            }
        }
        if(!buildinggranaryfarmer.empty())
        {
            build_granary=SN_to_building[buildinggranaryfarmer.back().WorkObjectSN];//记录谷仓
        }
        static bool market_build=false;//记录是否建造市场
        if(!market_build&&build_granary.Percent>=100&&info.Wood>=150)//建市场
        {
            Position p=Find_position(MAP,building_center.BlockDR+1,building_center.BlockUR+1,BUILDING_MARKET);//在市镇中心旁找能建市场的地方
            if(idlefarmer.size()>0)
            {
                HumanBuild(idlefarmer.back().SN,BUILDING_MARKET,p.x,p.y);//造市场
                transform_vector(idlefarmer,buildingmarketfarmer);//空闲农民去建市场
                market_build=true;
                info.Wood-=150;//纠正数量防冲突
            }
            else if(treefarmer.size()>0)
            {
                HumanBuild(treefarmer.back().SN,BUILDING_MARKET,p.x,p.y);//造市场
                transform_vector(treefarmer,buildingmarketfarmer);//空闲农民去建市场
                market_build=true;
                info.Wood-=150;//纠正数量防冲突
            }
        }
        if(!buildingmarketfarmer.empty())
        {
            building_market=SN_to_building[buildingmarketfarmer.back().WorkObjectSN];//记录市场
        }
        if (building_market.Percent>=100&&!wood_upgrade_started&&info.Wood>=75&&info.Meat>=120)//如果伐木升级尚未开始且资源足够，开始升级
        {
            BuildingAction(building_market.SN,BUILDING_MARKET_WOOD_UPGRADE);
            wood_upgrade_started=true;
            info.Wood-=75;//纠正数量防冲突
            info.Meat-=120;//纠正数量防冲突
        }
        if(building_market.Percent>=100&&idlefarmer.size()>0&&info.Wood>=75&&farmN<2)//2个农场
        {
            Position p=Find_position(MAP, building_center.BlockDR+1,building_center.BlockUR+1,BUILDING_FARM);//找到建农场地点
            HumanBuild(idlefarmer.back().SN,BUILDING_FARM,p.x,p.y);//建农场
            transform_vector(idlefarmer,farmfarmer);//空闲农民去建农场
            farmN++;
            info.Wood-=75;//纠正数量防冲突
        }
        if(wood_upgrade_started&&farmerN>=12&&idlefarmer.size()>0&&buildinghomefarmer.empty()&&HomeN<10&&info.Wood>=50)//村民达到上限，建房子至10个
        {
            homep=Find_position(MAP,homep.x,homep.y,BUILDING_HOME);//找到能建房地点
            HumanBuild(idlefarmer.back().SN,BUILDING_HOME,homep.x,homep.y);//建房子
            transform_vector(idlefarmer,buildinghomefarmer);//空闲村民到建房子
            HomeN++;
            info.Wood-=50;//纠正数量防冲突
        }
        static bool dock_build=false;//执行一次造船坞
        if(!dock_build&&wood_upgrade_started&&info.Wood>=120&&idlefarmer.size()>0)//再造一个船坞
        {
            Position p=Find_position(MAP,building_dock.BlockDR,building_dock.BlockUR,BUILDING_DOCK);//找到船坞能建造位置
            HumanBuild(idlefarmer.back().SN,BUILDING_DOCK,p.x,p.y);//建船坞
            transform_vector(idlefarmer,buildingdockfarmer);//空闲村民建船坞
            dock_build=true;
            info.Wood-=120;//纠正数量防冲突
        }
        if(!buildingdockfarmer.empty())
        {
            building_dock2_SN=buildingdockfarmer.back().WorkObjectSN;//映射到船坞的SN，用于区别另一个船坞
        }
        if(wood_upgrade_started&&info.Human_MaxNum>16&&farmerN<20&&info.Meat>=50&&building_center.Project==0)//使村民数达到20人
        {
            BuildingAction(building_center.SN,BUILDING_CENTER_CREATEFARMER);
            info.Meat-=50;
        }
        if(wood_upgrade_started&&info.Human_MaxNum>16&&info.Wood>=130&&shipN<6&&dock_build&&building_dock.Project==0)//满足开始建造船坞，伐木升级，木头大于130的条件后，开始造战船
        {
            BuildingAction(building_dock.SN,BUILDING_DOCK_CREATE_SHIP);//造战船
            shipN++;//战船数+1
            info.Wood-=130;
        }
        if(building_dock2.Percent>=100&&building_dock2.Project==0&&wood_upgrade_started&&info.Human_MaxNum>16&&info.Wood>=130&&shipN<8)//满足船坞2建好，伐木升级，木头大于130的条件后，也造战船
        {
            BuildingAction(building_dock2.SN,BUILDING_DOCK_CREATE_SHIP);//造战船
            info.Wood-=130;
        }
        static bool creat_move=false;//执行一次
        if(!creat_move)//执行一次
        {
            Position p;
            for(int j=3;j<map_size;j+=30)
            {
                p.x=3;
                p.y=j;
                movetowards.push_back(p);
            }
            for(int j=33;j<map_size;j+=30)
            {
                p.x=j;
                p.y=123;
                movetowards.push_back(p);
            }
            for(int j=93;j>0;j-=30)
            {
                p.x=123;
                p.y=j;
                movetowards.push_back(p);
            }
            for(int j=93;j>0;j-=30)
            {
                p.x=j;
                p.y=3;
                movetowards.push_back(p);
            }
            creat_move=true;
        }
        if(shipN>=8&&building_dock.Project==0&&building_dock2.Project==0&&idleship.size()>=5&&attackship.empty()&&isenemyland(visited,MAP))//找到敌方大陆
        {
            stage++;//找到敌方大陆，进入下一阶段
            cout<<"Reaching the next stage!"<<endl;
        }
        else if(shipN>=8&&building_dock.Project==0&&building_dock2.Project==0&&idleship.size()>=5&&attackship.empty()&&!isenemyland(visited,MAP))//未找到敌方大陆且船停下了
        {
            while(MAP[movetowards[towards].x][movetowards[towards].y]!='*')
            {
                towards+=1;//变换地点
            }
            double towardsx=movetowards[towards].x*BLOCKSIDELENGTH;
            double towardsy=movetowards[towards].y*BLOCKSIDELENGTH;
            while(idleship.size()>0)
            {
                HumanMove(idleship.back().SN,towardsx,towardsy);//移动至指定位置
                transform_vector(idleship,moveship);//移除空闲渔船
                towardsx-=12;
                towardsy-=12;
            }
        }
        for(tagArmy&enemy_army:info.enemy_armies)
        {
            if(enemy_army.Sort==AT_SHIP)
            {
                enemy_ship=&enemy_army;
                break;
            }
        }
        if(enemy_ship!=nullptr)//有敌船
        {
            while(!moveship.empty())
            {
                HumanAction(moveship.back().SN,enemy_ship->SN);//进攻敌船
                transform_vector(moveship,attackship);//移动战船到攻击战船
            }
            while(!idleship.empty())
            {
                HumanAction(idleship.back().SN,enemy_ship->SN);//进攻敌船
                transform_vector(idleship,attackship);//空闲战船到攻击战船
            }
        }
        while(idlefarmer.size()>0)//剩余的村民全部去砍树
        {
            Position p=Find_position(MAP,idlefarmer.back().BlockDR,idlefarmer.back().BlockUR,RESOURCE_TREE);//记录离村民最近的树的坐标
            if(p.x == -1 && p.y == -1)//如果没树了
                break;
            HumanAction(idlefarmer.back().SN,Position_to_SN[p]);//派村民砍树
            transform_vector(idlefarmer,treefarmer);//将空闲村民放入砍树村民
        }
    }
    //阶段3
    else if(stage==3)
    {
        if(idlesailing.size()>0)//有空闲的渔船
        {
            Position p=Find_position(MAP,idlesailing.back().BlockDR,idlesailing.back().BlockUR,RESOURCE_FISH);//记录离渔船最近的渔场的坐标
            if(p.x!=-1&&p.y!=-1)//还有渔场
            {
                HumanAction(idlesailing.back().SN,Position_to_SN[p]);//派空闲渔船捕鱼
                transform_vector(idlesailing,fishsailing);//将空闲渔船放入捕鱼渔船中
            }
        }
        for(tagArmy&enemy_army:info.enemy_armies)
        {
            if(enemy_army.Sort==AT_SHIP)
            {
                enemy_ship=&enemy_army;
                break;
            }
        }
        if(enemy_ship!=nullptr)//有敌船
        {
            while(!moveship.empty())
            {
                HumanAction(moveship.back().SN,enemy_ship->SN);//进攻敌船
                transform_vector(moveship,attackship);//移动战船到攻击战船
            }
            while(!idleship.empty())
            {
                HumanAction(idleship.back().SN,enemy_ship->SN);//进攻敌船
                transform_vector(idleship,attackship);//空闲战船到攻击战船
            }
        }
        static bool build_boat=false;//执行一次
        if(!build_boat&&info.Wood>=150)//建造一艘运输船
        {
            BuildingAction(building_dock.SN,BUILDING_DOCK_CREATE_WOOD_BOAT);
            build_boat=true;
        }
        static bool move_boat=false;//移动一次
        if(idleboat.size()>0&&!move_boat)
        {
            Position p=Find_position(MAP,building_center.BlockDR,building_center.BlockUR,'-');//查找海岸
            if(!OUTOFrange(p.x-1)&&IS_land(MAP[p.x-1][p.y]))//查找海洋区域周围是否有陆地
            {
                HumanMove(idleboat.back().SN,(p.x-1)*BLOCKSIDELENGTH,p.y*BLOCKSIDELENGTH);//向岸移动
            }
            else if(!OUTOFrange(p.y-1)&&IS_land(MAP[p.x][p.y-1]))//查找海洋区域周围是否有陆地
            {
                HumanMove(idleboat.back().SN,p.x*BLOCKSIDELENGTH,(p.y-1)*BLOCKSIDELENGTH);//向岸移动
            }
            else if(!OUTOFrange(p.x+1)&&IS_land(MAP[p.x+1][p.y]))//查找海洋区域周围是否有陆地
            {
                HumanMove(idleboat.back().SN,(p.x+1)*BLOCKSIDELENGTH,p.y*BLOCKSIDELENGTH);//向岸移动
            }
            else if(!OUTOFrange(p.y+1)&&IS_land(MAP[p.x][p.y+1]))//查找海洋区域周围是否有陆地
            {
                HumanMove(idleboat.back().SN,p.x*BLOCKSIDELENGTH,(p.y+1)*BLOCKSIDELENGTH);//向岸移动
            }
            transform_vector(idleboat,moveboat);//空闲运输船移动
            move_boat=true;
        }
        static bool move_boat1=false;//移动第二次
        static bool move_boat2=false;//移动第三次
        if(idleboat.size()>0&&move_boat&&onboatfarmer.size()<5&&!move_boat2)
        {
            if(idlefarmer.size()>0)
            {
                HumanAction(idlefarmer.back().SN,idleboat.back().SN);//移动至运输船
                transform_vector(idlefarmer,onboatfarmer);//空闲村民上船
            }
            else if(treefarmer.size()>0)
            {
                HumanAction(treefarmer.back().SN,idleboat.back().SN);//移动至运输船
                transform_vector(treefarmer,onboatfarmer);//空闲村民上船
            }
        }
        if(idleboat.size()>0&&idleboat.back().Resource==5&&!move_boat1)
        {
            for(int i=0;i<map_size;i++)
            {
                for(int j=0;j<map_size;j++)
                {
                    if(!move_boat1&&visited[i][j]==false&&IS_land(MAP[i][j]))
                    {
                        Position p=Find_position(MAP,i,j,'-');//找到靠岸海洋
                        HumanMove(idleboat.back().SN,p.x*BLOCKSIDELENGTH,p.y*BLOCKSIDELENGTH);//移动到敌方大陆
                        transform_vector(idleboat,moveboat);
                        move_boat1=true;
                    }
                }
            }
        }
        if(move_boat1&&idleboat.size()>0&&!move_boat2&&idleboat.back().Resource==5)
        {
            Position p=Find_position(MAP,idleboat.back().BlockDR,idleboat.back().BlockUR,'-');//查找海岸
            if(p.x!=-1&&p.y!=-1)//能找到海岸
            {
                if(!OUTOFrange(p.x-1)&&IS_land(MAP[p.x-1][p.y]))//查找海洋区域周围是否有陆地
                {
                    HumanMove(idleboat.back().SN,p.x*BLOCKSIDELENGTH-0.5,p.y*BLOCKSIDELENGTH+0.5);//向岸移动
                }
                else if(!OUTOFrange(p.y-1)&&IS_land(MAP[p.x][p.y-1]))//查找海洋区域周围是否有陆地
                {
                    HumanMove(idleboat.back().SN,p.x*BLOCKSIDELENGTH+0.5,p.y*BLOCKSIDELENGTH-0.5);//向岸移动
                }
                else if(!OUTOFrange(p.x+1)&&IS_land(MAP[p.x+1][p.y]))//查找海洋区域周围是否有陆地
                {
                    HumanMove(idleboat.back().SN,(p.x+1)*BLOCKSIDELENGTH+0.5,p.y*BLOCKSIDELENGTH+0.5);//向岸移动
                }
                else if(!OUTOFrange(p.y+1)&&IS_land(MAP[p.x][p.y+1]))//查找海洋区域周围是否有陆地
                {
                    HumanMove(idleboat.back().SN,p.x*BLOCKSIDELENGTH+0.5,(p.y+1)*BLOCKSIDELENGTH+0.5);//向岸移动
                }
                transform_vector(idleboat,moveboat);//空闲运输船移动
                move_boat2=true;
            }
        }
        if(stonefarmer.empty()&&idlefarmer.size()>0&&visited[idlefarmer.back().BlockDR][idlefarmer.back().BlockUR])//派一名在自己大陆的村民采石头
        {
             Position p=Find_position(MAP,idlefarmer.back().BlockDR,idlefarmer.back().BlockUR,RESOURCE_STONE);//记录离村民最近的石头的坐标
             if(p.x != -1 && p.y != -1)//如果有石头
             {
                 HumanAction(idlefarmer.back().SN,Position_to_SN[p]);//派村民采石头
                 transform_vector(idlefarmer,stonefarmer);//空闲村民去采石头
             }
        }
        while(idlefarmer.size()>0&&visited[idlefarmer.back().BlockDR][idlefarmer.back().BlockUR])//剩余的自己大陆的村民全部去砍树
        {
            Position p=Find_position(MAP,idlefarmer.back().BlockDR,idlefarmer.back().BlockUR,RESOURCE_TREE);//记录离村民最近的树的坐标
            if(p.x == -1 && p.y == -1)//如果没树了
                break;
            HumanAction(idlefarmer.back().SN,Position_to_SN[p]);//派村民砍树
            transform_vector(idlefarmer,treefarmer);//将空闲村民放入砍树村民
        }
    }
        //阶段4
    else if(stage==4)
    {
    }
    return ;
}







//函数：制作实时地图，并且完成映射，此处不判断斜面，注意：此地图仅包括我方单位，未放入敌方单位
void simple_map(char(&MAP)[map_size][map_size],tagInfo& info,map<int,int>&SN_to_sort,map<int,tagResource>&SN_to_resource,map<int,tagBuilding>&SN_to_building,map<Position,int>&Position_to_SN)
{
    for(int i=0;i<map_size;i++)//制作实时地图
    {
        for(int j=0;j<map_size;j++)
        {
            if((*info.theMap)[i][j].type==MAPPATTERN_OCEAN)
            {
                MAP[i][j]='-';//用'-'代表海洋
            }
            else if((*info.theMap)[i][j].type==MAPPATTERN_GRASS)
            {
                MAP[i][j]=(*info.theMap)[i][j].height+'0';//用高度代表陆地，数字类型为char
            }
            else
            {
                MAP[i][j]='*';//未知区域用'*'标记
            }
        }
    }
    for(tagResource& resource:info.resources)
    {
        MAP[resource.BlockDR][resource.BlockUR]=resource.Type;//对应资源类型
        Position p;
        p.x=resource.BlockDR;
        p.y=resource.BlockUR;
        Position_to_SN[p]=resource.SN;//资源块坐标到资源SN的映射
        SN_to_sort[resource.SN]=resource.Type;//资源SN到资源类型的映射
        SN_to_resource[resource.SN]=resource;//资源SN到资源的映射
        if(resource.Type==RESOURCE_FISH)//标记渔场占地：2*2
        {
            MAP[resource.BlockDR+1][resource.BlockUR]='+';
            MAP[resource.BlockDR][resource.BlockUR+1]='+';
            MAP[resource.BlockDR+1][resource.BlockUR+1]='+';
        }
        else if(resource.Type==RESOURCE_STONE)//标记石头占地：2*2
        {
            MAP[resource.BlockDR+1][resource.BlockUR]='+';
            MAP[resource.BlockDR][resource.BlockUR+1]='+';
            MAP[resource.BlockDR+1][resource.BlockUR+1]='+';
        }
    }
    for(tagBuilding& building:info.buildings)
    {
        MAP[building.BlockDR][building.BlockUR]=building.Type;//对应建筑类型
        SN_to_sort[building.SN]=building.Type;//建筑SN到建筑类型的映射
        SN_to_building[building.SN]=building;//建筑SN到建筑的映射
        switch(building.Type)
        {
        case BUILDING_HOME://标记房子占地：2*2
        case BUILDING_ARROWTOWER://标记箭塔占地
        case BUILDING_DOCK://标记船坞占地
            MAP[building.BlockDR+1][building.BlockUR]='+';
            MAP[building.BlockDR][building.BlockUR+1]='+';
            MAP[building.BlockDR+1][building.BlockUR+1]='+';
            break;
        case BUILDING_CENTER://标记市镇中心占地：3*3
        case BUILDING_GRANARY://标记谷仓占地
        case BUILDING_STOCK://标记仓库占地
        case BUILDING_ARMYCAMP://标记兵营占地
        case BUILDING_FARM://标记农场占地
        case BUILDING_MARKET://标记市场占地
        case BUILDING_RANGE://标记靶场占地
        case BUILDING_STABLE://标记马厩占地
            for(int i=0;i<3;i++)
            {
                for(int j=0;j<3;j++)
                {
                    if(i==0&&j==0)
                        continue;
                    MAP[building.BlockDR+i][building.BlockUR+j]='+';
                }
            }
            break;
        }
    }
    for(tagFarmer& farmer:info.farmers)
    {
        MAP[farmer.BlockDR][farmer.BlockUR]='+';//用'+'表示农民占据的块
    }
    for(tagArmy& army:info.armies)
    {
        MAP[army.BlockDR][army.BlockUR]='+';//用'+'表示我方军队占据的块
    }
    //判断斜面
    char MAP_slope[128][128]={0};//记录斜面
    int unitDR[unit_max]={1,-1,0,0,1,1,-1,-1};//查找方向
    int unitUR[unit_max]={0,0,1,-1,1,-1,1,-1};//右，左，上，下，右上，右下，左上，左下
    for(int i=0;i<map_size;i++)
    {
        for(int j=0;j<map_size;j++)
        {
            if(IS_land(MAP[i][j]))//在陆地上且没有被占据
            {
                for(int k=0;k<unit_max;k++)//遍历4个方向
                {
                    if(!OUTOFrange(i+unitDR[k]))//不出界
                    {
                        if(!OUTOFrange(j+unitUR[k]))//不出界
                        {
                            if(IS_land(MAP[i+unitDR[k]][j+unitUR[k]]))//相邻点在陆地上且没有被占据
                            {
                                if(MAP[i+unitDR[k]][j+unitUR[k]]!=MAP[i][j])//高度不同
                                {
                                    MAP_slope[i+unitDR[k]][j+unitUR[k]]='/';
                                    MAP_slope[i][j]='/';//将两点坐标都记录为斜面
                                }
                            }

                        }
                    }
                }
            }
        }
    }
    for(int i=0;i<map_size;i++)//遍历记录斜面的数组
    {
        for(int j=0;j<map_size;j++)
        {
            if(MAP_slope[i][j]=='/')//标记斜面
                MAP[i][j]='/';
        }
    }
}

//函数：判断坐标是否超出范围,1代表超界,0代表未超界,配合continue使用
int OUTOFrange(const int& x)
{
    if(x<0||x>=map_size)
        return 1;
    return 0;
}

//函数：判断坐标是否在陆地上且没有被占据,输入MAP[][],返回1代表在陆地上,返回代表不在，配合if判断语句
int IS_land(const char& z)
{
    if(z>=height_min&&z<=height_max)
        return 1;
    return 0;
}

//函数：打印一次MAP，用于测试
void MAP_print(char(&MAP)[map_size][map_size],int &flag)
{
    if(flag==-1)//flag=-1时打印MAP
    {
        for(int i=map_size-1;i>=0;i--)
        {
            for(int j=0;j<map_size;j++)
            {
                cout<<MAP[j][i];
            }
            cout<<endl;
        }
    }
    flag=0;
}

//函数，查找距离指定坐标最近的某个资源的坐标，或用于在指定坐标周围找空地建房子
Position Find_position(char(&MAP)[map_size][map_size],int blockdr,int blockur,int type)
{
    int unitDR[unit_max]={1,-1,0,0,1,1,-1,-1};//农民行走方向
    int unitUR[unit_max]={0,0,1,-1,1,-1,1,-1};//右，左，上，下，右上，右下，左上，左下
    bool visited[map_size][map_size]={false};//创造一个bool数组判断点是否被访问过
    int near_distance[map_size][map_size]={0};//创造一个用来记录距离的数组
    queue<Position>q;//创造队列，用BFS算法
    Position p;
    int t=0;
    if(type==BUILDING_STOCK)//空出建筑旁边的路用于走路
        t=1;
    else if(type==BUILDING_CENTER)
        t=8;
    else if(type==BUILDING_HOME)
        t=3;
    else if(type==BUILDING_DOCK)
        t=3;
    else if(type==BUILDING_FARM)
        t=4;
    else if(type==BUILDING_MARKET)
        t=8;
    else if(type==BUILDING_GRANARY)
        t=8;
    if (!OUTOFrange(blockdr) && !OUTOFrange(blockur) &&(MAP[blockdr][blockur] == RESOURCE_TREE||MAP[blockdr][blockur]==RESOURCE_FISH))//检查起点是否为目标资源(树,鱼)
    {
        p.x=blockdr;
        p.y=blockur;
        return p;//返回村民坐标
    }
    visited[blockdr][blockur] = true;//标记村民的位置为已访问
    near_distance[blockdr][blockur]=0;//标记村民的位置为距离0
    q.push({blockdr,blockur});//将农民位置加入队列
    while(!q.empty())//如果q不为空，进入循环
    {
        int size=q.size();//q中元素数
        for(int i=0;i<size;i++)
        {
            p=q.front();//取出q首元素放入p
            q.pop();//删除q首元素
            for(int j=0;j<unit_max;j++)//查找八个方向的点
            {
                int dr=p.x+unitDR[j];
                int ur=p.y+unitUR[j];
                if(OUTOFrange(dr)||OUTOFrange(ur)||visited[dr][ur])//出界或被访问过的坐标跳过不访问
                    continue;
                visited[dr][ur]=true;//表示已找过
                near_distance[dr][ur]=near_distance[p.x][p.y]+1;//距离加1
                if(near_distance[dr][ur]>=t)//离起点t距离开始找资源或满足建筑建造的需求的地点
                {
                    if(type==BUILDING_HOME||type==BUILDING_CENTER)//市镇中心周围建房
                    {
                        bool findit=true;
                        for(int i=0;i<3;i++)
                        {
                            for(int j=0;j<3;j++)
                            {
                                int nx=dr+i;
                                int ny=ur+j;
                                if(!OUTOFrange(nx)&&!OUTOFrange(ny)&&IS_land(MAP[nx][ny])&&MAP[dr][ur]==MAP[nx][ny])//判断3*3范围内是否超界,是否为陆地,是否高度相等
                                    continue;
                                else
                                    findit=false;
                            }
                        }
                        if(findit==true)//找到了位置
                        {
                            p.x=dr;
                            p.y=ur;
                            return p;
                        }
                    }
                    else if(type==BUILDING_STOCK||type==BUILDING_FARM||type==BUILDING_MARKET||type==BUILDING_GRANARY)//某坐标周围建仓库,农田,市场，谷仓
                    {
                        bool findit=true;
                        for(int i=0;i<4;i++)
                        {
                            for(int j=0;j<4;j++)
                            {
                                int nx=dr+i;
                                int ny=ur+j;
                                if(!OUTOFrange(nx)&&!OUTOFrange(ny)&&IS_land(MAP[nx][ny])&&MAP[dr][ur]==MAP[nx][ny])//判断4*4范围内是否超界,是否为陆地,是否高度相等
                                    continue;
                                else
                                    findit=false;
                            }
                        }
                        if(findit==true)//找到了位置
                        {
                            p.x=dr;
                            p.y=ur;
                            return p;
                        }
                    }
                    else if(type==BUILDING_DOCK)//某坐标周围建船坞
                    {
                        if(!OUTOFrange(dr+1)&&
                                !OUTOFrange(ur+1)&&
                                MAP[dr][ur]=='-'&&
                                MAP[dr + 1][ur] == '-' &&
                                MAP[dr][ur + 1] == '-' &&
                                MAP[dr + 1][ur + 1] == '-')//检查2*2区域是否为海洋和是否超界
                        {
                            bool can_build_dock=false;
                            if(!OUTOFrange(dr-1)&&IS_land(MAP[dr-1][ur])&&IS_land(MAP[dr-1][ur+1]))//查找海洋区域周围是否有两格陆地且不超界
                                can_build_dock=true;
                            else if(!OUTOFrange(ur-1)&&IS_land(MAP[dr][ur-1])&&IS_land(MAP[dr+1][ur-1]))
                                can_build_dock=true;
                            else if(!OUTOFrange(dr+2)&&IS_land(MAP[dr+2][ur])&&IS_land(MAP[dr+2][ur+1]))
                                can_build_dock=true;
                            else if(!OUTOFrange(ur+2)&&IS_land(MAP[dr][ur+2])&&IS_land(MAP[dr+1][ur+2]))
                                can_build_dock=true;
                            if(can_build_dock==true)
                            {
                                p.x=dr;
                                p.y=ur;
                                return p;//返回可建船坞的海洋坐标
                            }
                        }
                    }
                    else if(type==RESOURCE_TREE)//找树
                    {
                        if(MAP[dr][ur]==RESOURCE_TREE)//找到树
                        {
                            p.x=dr;
                            p.y=ur;
                            return p;//返回树坐标
                        }
                    }
                    else if(type==RESOURCE_FISH)//找渔场
                    {
                        if(MAP[dr][ur]==RESOURCE_FISH)//找到渔场在地图上的标识
                        {
                            p.x=dr;
                            p.y=ur;
                            return p;//返回渔场坐标
                        }
                    }
                    else if(type==RESOURCE_GAZELLE)//找瞪羚
                    {
                        if(MAP[dr][ur]==RESOURCE_GAZELLE)//找到瞪羚在地图上的标识
                        {
                            p.x=dr;
                            p.y=ur;
                            return p;//返回瞪羚坐标
                        }
                    }
                    else if(type==RESOURCE_STONE)//找石头
                    {
                        if(MAP[dr][ur]==RESOURCE_STONE)
                        {
                            p.x=dr;
                            p.y=ur;
                            return p;//返回石头坐标
                        }
                    }
                    else if(type=='-')
                    {
                        if(MAP[dr][ur]=='-')//检查2*2区域是否为海洋和是否超界
                        {
                            bool can_move=false;
                            if(!OUTOFrange(dr-1)&&IS_land(MAP[dr-1][ur]))//查找海洋区域周围是否有陆地
                                can_move=true;
                            else if(!OUTOFrange(ur-1)&&IS_land(MAP[dr][ur-1]))
                                can_move=true;
                            else if(!OUTOFrange(dr+1)&&IS_land(MAP[dr+1][ur]))
                                can_move=true;
                            else if(!OUTOFrange(ur+1)&&IS_land(MAP[dr][ur+1]))
                                can_move=true;
                            if(can_move==true)
                            {
                                p.x=dr;
                                p.y=ur;
                                return p;//返回海洋坐标
                            }
                        }
                    }
                }
                q.push({dr,ur});//将找过的坐标加入队列
            }
        }
    }
    return {-1,-1};//没找到该资源
}

//函数：用于将一个vector数组的末尾放入另一个数组末尾，并删除前一个的末尾
void transform_vector(vector<tagFarmer>& farmer1,vector<tagFarmer>& farmer2)
{
    farmer2.push_back(farmer1.back());
    farmer1.pop_back();
}
void transform_vector(vector<tagArmy>& army1,vector<tagArmy>& army2)
{
    army2.push_back(army1.back());
    army1.pop_back();
}

//检查周围区域视野内是否有敌方大陆
bool isenemyland(bool(&visited)[map_size][map_size],char(&MAP)[map_size][map_size])
{
    for(int i=0;i<map_size;i++)
    {
        for(int j=0;j<map_size;j++)
        {
            if(visited[i][j]==false&&IS_land(MAP[i][j]))
            {
                return true;
            }
        }
    }
    return false;
}
